package com.qms.qep.service.impl;

import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.ArrayList;
import java.util.HashMap;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.qms.common.exception.ServiceException;
import com.qms.common.utils.StringUtils;
import com.qms.qep.mapper.InspectionDataMapper;
import com.qms.qep.mapper.InspectionTaskMapper;
import com.qms.qep.mapper.InspectionStandardItemMapper;
import com.qms.qep.domain.InspectionData;
import com.qms.qep.domain.InspectionTask;
import com.qms.qep.domain.InspectionStandardItem;
import com.qms.qep.domain.dto.InspectionDataDTO;
import com.qms.qep.service.IInspectionDataService;

/**
 * 检验数据Service业务层处理
 * 
 * @author qms
 * @date 2025-05-14
 */
@Service
public class InspectionDataServiceImpl implements IInspectionDataService 
{
    @Autowired
    private InspectionDataMapper inspectionDataMapper;

    @Autowired
    private InspectionTaskMapper inspectionTaskMapper;

    @Autowired
    private InspectionStandardItemMapper inspectionStandardItemMapper;

    /**
     * 查询检验数据
     * 
     * @param id 检验数据主键
     * @return 检验数据
     */
    @Override
    public InspectionData selectInspectionDataById(Integer id)
    {
        return inspectionDataMapper.selectInspectionDataById(id);
    }

    /**
     * 查询检验数据列表
     * 
     * @param inspectionData 检验数据
     * @return 检验数据
     */
    @Override
    public List<InspectionData> selectInspectionDataList(InspectionData inspectionData)
    {
        return inspectionDataMapper.selectInspectionDataList(inspectionData);
    }
    
    /**
     * 查询检验数据DTO列表
     * 
     * @param inspectionData 检验数据
     * @return 检验数据DTO
     */
    @Override
    public List<InspectionDataDTO> selectInspectionDataDTOList(InspectionData inspectionData) {
        return inspectionDataMapper.selectInspectionDataDTOList(inspectionData);
    }
    
    /**
     * 根据任务ID查询检验数据
     * 
     * @param taskId 任务ID
     * @return 检验数据集合
     */
    @Override
    public List<InspectionData> selectInspectionDataByTaskId(Integer taskId) {
        return inspectionDataMapper.selectInspectionDataByTaskId(taskId);
    }
    
    /**
     * 根据任务ID查询检验数据DTO
     * 
     * @param taskId 任务ID
     * @return 检验数据DTO集合
     */
    @Override
    public List<InspectionDataDTO> selectInspectionDataDTOByTaskId(Integer taskId) {
        return inspectionDataMapper.selectInspectionDataDTOByTaskId(taskId);
    }

    /**
     * 新增检验数据
     * 
     * @param inspectionData 检验数据
     * @return 结果
     */
    @Override
    public int insertInspectionData(InspectionData inspectionData)
    {
        inspectionData.setCreateTime(new Date());
        return inspectionDataMapper.insertInspectionData(inspectionData);
    }

    /**
     * 批量新增检验数据
     * 
     * @param inspectionDataList 检验数据列表
     * @return 结果
     */
    @Override
    public int batchInsertInspectionData(List<InspectionData> inspectionDataList)
    {
        return inspectionDataMapper.batchInsertInspectionData(inspectionDataList);
    }

    /**
     * 修改检验数据
     * 
     * @param inspectionData 检验数据
     * @return 结果
     */
    @Override
    public int updateInspectionData(InspectionData inspectionData)
    {
        return inspectionDataMapper.updateInspectionData(inspectionData);
    }

    /**
     * 批量删除检验数据
     * 
     * @param ids 需要删除的检验数据主键
     * @return 结果
     */
    @Override
    public int deleteInspectionDataByIds(Integer[] ids)
    {
        return inspectionDataMapper.deleteInspectionDataByIds(ids);
    }

    /**
     * 删除检验数据信息
     * 
     * @param id 检验数据主键
     * @return 结果
     */
    @Override
    public int deleteInspectionDataById(Integer id)
    {
        return inspectionDataMapper.deleteInspectionDataById(id);
    }
    
    /**
     * 根据任务ID删除检验数据
     * 
     * @param taskId 任务ID
     * @return 结果
     */
    @Override
    public int deleteInspectionDataByTaskId(Integer taskId) {
        return inspectionDataMapper.deleteInspectionDataByTaskId(taskId);
    }
    
    /**
     * 根据ID列表查询检验数据
     * 
     * @param ids 检验数据ID列表
     * @return 检验数据集合
     */
    @Override
    public List<InspectionData> selectInspectionDataByIds(List<Integer> ids) {
        return inspectionDataMapper.selectInspectionDataByIds(ids);
    }
    
    /**
     * 导入Excel检验数据
     * 
     * @param dataList 数据列表
     * @param taskId 任务ID
     * @param updateSupport 是否更新已存在数据
     * @param operName 操作人
     * @return 结果
     */
    @Override
    @Transactional
    public String importData(List<InspectionData> dataList, Integer taskId, Boolean updateSupport, String operName) {
        if (StringUtils.isNull(dataList) || dataList.size() == 0) {
            throw new ServiceException("导入数据不能为空！");
        }
        
        int successNum = 0;
        int failureNum = 0;
        StringBuilder successMsg = new StringBuilder();
        StringBuilder failureMsg = new StringBuilder();
        
        for (InspectionData data : dataList) {
            try {
                // 设置任务ID
                data.setTaskId(taskId);
                // 如果没有合格状态，则判断
                if (data.getIsQualified() == null) {
                    if (StringUtils.isNotEmpty(data.getMeasuredValue()) && StringUtils.isNotEmpty(data.getStandardValue())) {
                        data.setIsQualified(isQualified(data.getMeasuredValue(), data.getStandardValue()) ? 1 : 0);
                    }
                }
                // 设置创建时间
                data.setCreateTime(new Date());
                
                // 插入数据
                inspectionDataMapper.insertInspectionData(data);
                successNum++;
                successMsg.append("<br/>" + successNum + "、参数 " + data.getParamName() + " 导入成功");
            } catch (Exception e) {
                failureNum++;
                String msg = "<br/>" + failureNum + "、参数 " + data.getParamName() + " 导入失败：";
                failureMsg.append(msg + e.getMessage());
            }
        }
        
        if (failureNum > 0) {
            failureMsg.insert(0, "很抱歉，导入失败！共 " + failureNum + " 条数据格式不正确，错误如下：");
            throw new ServiceException(failureMsg.toString());
        } else {
            successMsg.insert(0, "恭喜您，数据已全部导入成功！共 " + successNum + " 条，数据如下：");
        }
        
        return successMsg.toString();
    }
    
    /**
     * 判断实测值是否在标准值范围内
     * 
     * @param measuredValue 实测值
     * @param standardValue 标准值
     * @return 是否合格
     */
    private boolean isQualified(String measuredValue, String standardValue) {
        if (measuredValue == null || standardValue == null) {
            return false;
        }
        
        try {
            // 根据不同格式判断
            if (standardValue.contains("~") || standardValue.contains("-")) {
                // 范围型标准值，如: 10~20 或 10-20
                String[] range = standardValue.replace("~", "-").split("-");
                if (range.length < 2) {
                    return false;
                }
                double min = Double.parseDouble(range[0].trim());
                double max = Double.parseDouble(range[1].trim());
                double value = Double.parseDouble(measuredValue.trim());
                return value >= min && value <= max;
            } else if (standardValue.contains("±")) {
                // 偏差型标准值，如: 10±0.5
                String[] parts = standardValue.split("±");
                if (parts.length < 2) {
                    return false;
                }
                double base = Double.parseDouble(parts[0].trim());
                double deviation = Double.parseDouble(parts[1].trim());
                double value = Double.parseDouble(measuredValue.trim());
                return value >= (base - deviation) && value <= (base + deviation);
            } else if (standardValue.contains(">")) {
                // 大于型标准值，如: >10
                double limit = Double.parseDouble(standardValue.replace(">", "").trim());
                double value = Double.parseDouble(measuredValue.trim());
                return value > limit;
            } else if (standardValue.contains("≥")) {
                // 大于等于型标准值，如: ≥10
                double limit = Double.parseDouble(standardValue.replace("≥", "").trim());
                double value = Double.parseDouble(measuredValue.trim());
                return value >= limit;
            } else if (standardValue.contains("<")) {
                // 小于型标准值，如: <10
                double limit = Double.parseDouble(standardValue.replace("<", "").trim());
                double value = Double.parseDouble(measuredValue.trim());
                return value < limit;
            } else if (standardValue.contains("≤")) {
                // 小于等于型标准值，如: ≤10
                double limit = Double.parseDouble(standardValue.replace("≤", "").trim());
                double value = Double.parseDouble(measuredValue.trim());
                return value <= limit;
            } else {
                try {
                    // 尝试作为数值比较
                    double standard = Double.parseDouble(standardValue.trim());
                    double value = Double.parseDouble(measuredValue.trim());
                    return Math.abs(standard - value) < 0.00001; // 浮点数比较
                } catch (NumberFormatException e) {
                    // 如果不是数值型，直接比较字符串
                    return standardValue.trim().equals(measuredValue.trim());
                }
            }
        } catch (Exception e) {
            // 如果解析失败，返回不合格
            return false;
        }
    }

    /**
     * 根据任务ID获取检验参数列表及其标准值
     * 
     * @param taskId 任务ID
     * @return 参数列表及标准值
     */
    @Override
    public List<Map<String, Object>> getParametersByTaskId(Long taskId) {
        // 首先获取任务信息
        InspectionTask task = inspectionTaskMapper.selectInspectionTaskById(taskId.intValue());
        if (task == null) {
            return new ArrayList<>();
        }
        
        // 获取产品ID和工序ID
        Integer productId = task.getProductId();
        Integer processId = task.getProcessId();
        
        // 查询适用于该产品和工序的检验标准项
        List<Map<String, Object>> parameterList = new ArrayList<>();
        
        // 构建查询条件
        InspectionStandardItem queryItem = new InspectionStandardItem();
        // 设置产品ID条件
        queryItem.setProductId(productId != null ? productId.longValue() : null);
        
        // 查询参数列表 - 只用产品ID作为主要条件
        List<InspectionStandardItem> standardItems = inspectionStandardItemMapper.selectInspectionStandardItemList(queryItem);
        
        // 记录工序ID用于日志
        if (processId != null) {
            System.out.println("当前工序ID: " + processId + "，查询到标准项数量: " + standardItems.size());
        }
        
        // 转换为前端需要的格式
        for (InspectionStandardItem item : standardItems) {
            Map<String, Object> map = new HashMap<>();
            map.put("id", item.getId());
            map.put("paramName", item.getName()); // 使用getName()而不是getParamName()
            map.put("standardValue", item.getValue()); // 使用getValue()而不是getStandardValue()
            map.put("unit", item.getUnit());
            map.put("paramType", item.getType()); // 使用getType()而不是getParamType()
            parameterList.add(map);
        }
        
        return parameterList;
    }
} 